The implementation of `from_pairs` can be simplified by using `unzip`, which is more idiomatic and likely more efficient. I've also renamed the parameter from `triples` to `pairs` for clarity.

```suggestion
    pub fn from_pairs(pairs: impl IntoIterator<Item = (u32, f32)>) -> Self {
        let (indices, values) = pairs.into_iter().unzip();
        Self {
            indices,
            values,
            tokens: None,
        }
    }
```

File: rust/types/src/metadata.rs
Line: 114

This new logic to add `value_token` is a great addition. However, it doesn't appear to be covered by tests. The existing tests for sparse vectors seem to only cover cases where tokens are not provided, exercising the `None` path for `stable_value_token`.

To ensure this new functionality is robust, could you please add a test case with a `SparseVector` that includes tokens? This test should assert that the `value_token` field is correctly populated in the resulting statistics records. This would likely require updating test helpers like `extract_metadata_tuple` as well.

File: rust/worker/src/execution/functions/statistics.rs
Line: 255

**Resource leak in concurrent compaction handling**: The `clone()` operations at lines 603-604 create deep copies of `log_fetch_records` and entire `CompactionContext` for parallel execution. With large datasets (e.g., 10k records), this duplicates significant memory without cleanup guarantees if one future fails.

```rust
// Current: Clones entire state
let log_fetch_records_clone = log_fetch_records.clone();
let mut self_clone_fn = self.clone();

// Safer approach: Use Arc to share data
let log_fetch_records = Arc::new(log_fetch_records);
let fn_records = Arc::clone(&log_fetch_records);
```

File: rust/worker/src/execution/orchestration/compact.rs
Line: 604

**Potential panic from unbounded recursion**: `Box::pin()` at line 723 wraps an async function that can recursively call itself through orchestrator chains. With deep call stacks (e.g., multiple attached functions), this risks stack overflow despite the 8MB thread stack allocation in tests.

```rust
// Add depth tracking to prevent unbounded recursion
pub async fn compact(
    // ... params
    max_depth: Option<u32>,
) -> Result<CompactionResponse, CompactionError> {
    if let Some(depth) = max_depth {
        if depth == 0 {
            return Err(CompactionError::InvariantViolation(
                "Maximum orchestration depth exceeded".to_string()
            ));
        }
    }
    // ... rest of function
}
```

File: rust/worker/src/execution/orchestration/compact.rs
Line: 723

**Missing error propagation in cleanup path**: `cleanup()` at line 666 uses `let _ =` to ignore HNSW purge errors. If cleanup fails during error handling (e.g., disk full), subsequent compactions will leak resources without visibility.

```rust
pub(crate) async fn cleanup(self) {
    let mut cleanup_errors = Vec::new();
    for hnsw_index_uuid in self.hnsw_index_uuids {
        if let Err(e) = HnswIndexProvider::purge_one_id(
            self.hnsw_provider.temporary_storage_path.as_path(),
            hnsw_index_uuid,
        ).await {
            cleanup_errors.push((hnsw_index_uuid, e));
        }
    }
    if !cleanup_errors.is_empty() {
        tracing::warn!("Cleanup failures: {:?}", cleanup_errors);
    }
}
```

File: rust/worker/src/execution/orchestration/compact.rs
Line: 671

For consistency with the other match arms in this `PartialEq` implementation, you can remove the braces and use a single expression with a trailing comma.

File: rust/worker/src/execution/functions/statistics.rs
Line: 175